<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title></title>
	</head>
	<body>
		<script src="lodash.min.js"></script>
		<script>
			let lodash=_,arr=['a', 'b', 'c', 'd',1,2,3,4]
			// _.chunk(array, [size=1])将数组（array）拆分成多个 size 长度的区块，并将这些区块组成一个新数组。 如果array 无法被分割成全部等长的区块，那么最后剩余的元素将组成一个区块
			console.log(lodash.chunk(arr, 3));
			
			// 创建一个新数组，包含原数组中所有的非假值元素。例如false, null,0, "", undefined, 和 NaN 都是被认为是“假值”。
			console.log(lodash.compact([0, 1, false, 2, '', 3]));
			
			// 不同于原生concat，他不会展开传入的数组
			console.log(lodash.concat([55], 2, [3], [[4]]));
			
			// 第二个数组有4、2，他会把第一个数组的4、2去掉
			console.log(_.difference([3, 2, 1], [4, 2]));
			
			// 第三个参数作为比较标准，可以把指定对象去除；differenceWith第三个只支持传函数
			// by和with通常用于对象数组
			console.log(_.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x'),_.differenceBy([3.1, 2.2, 1.3], [4.4, 2.5], Math.floor),_.differenceWith([{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }], [{ 'x': 1, 'y': 2 }], _.isEqual));
			
			// 创建一个切片数组，去除array前面的n个元素。（n默认值为1。）
			console.log(_.drop([1, 2, 3], 2));
			
			// 创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）
			console.log(_.dropRight([1, 2, 3], 2));
			
			// 使用 value 值来填充（替换） array，从start(1)位置开始, 到end(3)位置结束（但不包含end(3)位置）。
			console.log(_.fill([4, 6, 8, 10], '*', 1, 3));
			
			// 该方法类似_.find，区别是该方法返回第一个从2开始通过判断为真值的元素的索引值（index），_.findLastIndex类似
			console.log(_.findIndex([{a:1,b:4},{a:2,b:4},{a:2,b:6}], {a:2},2));
			
			// 可以理解为给定数组的交集,intersectionBy可以加一个函数或字符串作为判断、intersectionWith可以加一个函数作为判断，三者区别类似difference
			console.log(_.intersection([2, 1], [4, 2], [1, 2]));
			
			// 移除数组array中所有和给定值相等的元素;pullAll类似_.pull，区别是pullAll接收要移除值的数组;此外还存在pullBy、pullWith；_.without类似, 这个方法会返回一个新数组，不会改变原数组
			console.log(_.pull([1,2,2,3,4,5], 2, 3));
			
			// 使用二进制的方式检索来决定 value值 应该插入到数组中 尽可能小的索引位置
			console.log(_.sortedIndex([30, 50], 40));
			
			// 根据 depth 递归减少 array 的嵌套层级
			console.log(_.flattenDepth([1, [2, [3, [4]], 5]], 2));
			
			// 与_.toPairs正好相反
			console.log(_.fromPairs([['fred', 30], ['barney', 40]]));  // => { 'fred': 30, 'barney': 40 }
			_.zipObject(['a', 'b'], [1, 2]);  // => { 'a': 1, 'b': 2 }
			
			// 创建一个数组切片，从array数组的起始元素开始提取n个元素;_.takeRight从array数组的最后一个元素开始提取n个元素
			_.take([1, 2, 3], 2);   // => [1, 2]
			
			// 去掉重复部分并合成数组
			console.log(_.union([2], [1, 2],[3,2]));
			
			// 去掉重复元素
			console.log(_.uniq([2, 1, 2]),_.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x'));
			
			
			// 数组（矩阵）压缩
			_.zip(['fred', 'barney'], [30, 40], [true, false]);
			// => [['fred', 30, true], ['barney', 40, false]]

			// unionWith把满足参数3函数的去掉
			var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
			var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
			console.log(_.unionWith(objects, others, function(o){return o.x>10}));
			
			
			// 移除数组中predicate（断言）返回为真值的所有元素，并返回移除元素组成的数组
			var array = [1, 2, 3, 4];
			var evens = _.remove(array, function(n) {
			  return n % 2 == 0;
			});
			console.log(array);
			// => [1, 3]
			console.log(evens);
			// => [2, 4]
			
			// _.takeWhile(array, [predicate=_.identity])   从array数组的起始元素开始提取元素,直到 predicate 返回假值。predicate 会传入三个参数： (value, index, array)，takeWhileRight反向提取
			var users = [
			  { 'user': 'barney',  'active': false },
			  { 'user': 'fred',    'active': false},
			  { 'user': 'pebbles', 'active': true }
			];
			_.takeWhile(users, function(o) { return !o.active; });
			// => objects for ['barney', 'fred']
			_.takeWhile(users, { 'user': 'barney', 'active': false });
			// => objects for ['barney']
			_.takeWhile(users, ['active', false]);
			// => objects for ['barney', 'fred']
			_.takeWhile(users, 'active');
			// => []
			
			
		</script>
	</body>
</html>